package com.freeter.modules.gjs.service.impl;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.freeter.common.exception.RRException;
import com.freeter.modules.gjs.entity.MstrUom;
import com.freeter.modules.gjs.mapper.MstrUomMapper;
import com.freeter.modules.gjs.service.MstrUomService;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class MstrUomServiceImpl implements MstrUomService {
    
    private static final Logger logger = LoggerFactory.getLogger(MstrUomServiceImpl.class);
    
    @Autowired
    private MstrUomMapper mstrUomMapper;

    public List<MstrUom> getUomsByCondition(String name, Integer state) {
        Wrapper<MstrUom> wrapper = new EntityWrapper<>();
        if (name != null) wrapper.eq("desc_en", name);
        if (state != null) wrapper.eq("is_deleted", state);
        return mstrUomMapper.selectList(wrapper);
    }

    @Override
    public List<MstrUom> getAllUoms() {
        try {
            Wrapper<MstrUom> queryWrapper = new EntityWrapper<>();
            queryWrapper.eq("is_deleted", 0); // 只查询未删除的记录
            return mstrUomMapper.selectList(queryWrapper);
        } catch (Exception e) {
            logger.error("获取所有单位信息失败", e);
            throw new RRException("获取单位信息失败：" + e.getMessage());
        }
    }

    @Override
    public MstrUom getUomById(Long id) {
        try {
            if (id == null || id <= 0) {
                throw new RRException("单位ID不能为空或无效");
            }
            
            MstrUom uom = mstrUomMapper.selectById(id);
            if (uom == null || uom.getIsDeleted() == 1) {
                return null;
            }
            return uom;
        } catch (RRException e) {
            throw e;
        } catch (Exception e) {
            logger.error("根据ID获取单位信息失败，ID: {}", id, e);
            throw new RRException("获取单位信息失败：" + e.getMessage());
        }
    }

    @Override
    public MstrUom getUomByCode(String uomCode) {
        try {
            if (StringUtils.isBlank(uomCode)) {
                throw new RRException("单位编码不能为空");
            }
            
            Wrapper<MstrUom> wrapper = new EntityWrapper<>();
            wrapper.eq("desc_en", uomCode.trim())
                   .eq("is_deleted", 0);
            
            List<MstrUom> uoms = mstrUomMapper.selectList(wrapper);
            return uoms.isEmpty() ? null : uoms.get(0);
        } catch (RRException e) {
            throw e;
        } catch (Exception e) {
            logger.error("根据编码获取单位信息失败，编码: {}", uomCode, e);
            throw new RRException("获取单位信息失败：" + e.getMessage());
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public MstrUom createUom(MstrUom uom) {
        try {
            if (uom == null) {
                throw new RRException("单位信息不能为空");
            }
            
            // 验证必填字段
            if (StringUtils.isBlank(uom.getDescEn())) {
                throw new RRException("单位英文描述不能为空");
            }
            
            // 检查是否已存在相同编码的单位
            MstrUom existingUom = getUomByCode(uom.getDescEn());
            if (existingUom != null) {
                return  existingUom;
            }
            
            // 设置默认值
            uom.setIsDeleted(0);
            if (uom.getAllowDec() == null) {
                uom.setAllowDec(0); // 默认不允许小数
            }
            
            // 插入数据
            int result = mstrUomMapper.insert(uom);
            if (result <= 0) {
                throw new RRException("创建单位信息失败");
            }
            
            logger.info("成功创建单位信息，ID: {}, 编码: {}", uom.getId(), uom.getDescEn());
            return uom;
        } catch (RRException e) {
            throw e;
        } catch (Exception e) {
            logger.error("创建单位信息失败", e);
            throw new RRException("创建单位信息失败：" + e.getMessage());
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public MstrUom updateUom(Long id, MstrUom uom) {
        try {
            if (id == null || id <= 0) {
                throw new RRException("单位ID不能为空或无效");
            }
            if (uom == null) {
                throw new RRException("单位信息不能为空");
            }
            
            // 检查单位是否存在
            MstrUom existingUom = getUomById(id);
            if (existingUom == null) {
                throw new RRException("单位不存在，ID: " + id);
            }
            
            // 如果修改了编码，需要检查新编码是否已存在
            if (StringUtils.isNotBlank(uom.getDescEn()) && 
                !uom.getDescEn().equals(existingUom.getDescEn())) {
                MstrUom duplicateUom = getUomByCode(uom.getDescEn());
                if (duplicateUom != null) {
                    throw new RRException("单位编码已存在：" + uom.getDescEn());
                }
            }
            
            // 设置更新字段
            uom.setId(id);
            if (uom.getIsDeleted() == null) {
                uom.setIsDeleted(existingUom.getIsDeleted());
            }
            
            // 更新数据
            int result = mstrUomMapper.updateById(uom);
            if (result <= 0) {
                throw new RRException("更新单位信息失败");
            }
            
            logger.info("成功更新单位信息，ID: {}", id);
            return getUomById(id);
        } catch (RRException e) {
            throw e;
        } catch (Exception e) {
            logger.error("更新单位信息失败，ID: {}", id, e);
            throw new RRException("更新单位信息失败：" + e.getMessage());
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteUom(Long id) {
        try {
            if (id == null || id <= 0) {
                throw new RRException("单位ID不能为空或无效");
            }
            
            // 检查单位是否存在
            MstrUom existingUom = getUomById(id);
            if (existingUom == null) {
                throw new RRException("单位不存在，ID: " + id);
            }
            
            // 软删除：设置删除标志
            MstrUom updateUom = new MstrUom();
            updateUom.setId(id);
            updateUom.setIsDeleted(1);
            
            int result = mstrUomMapper.updateById(updateUom);
            if (result <= 0) {
                throw new RRException("删除单位信息失败");
            }
            
            logger.info("成功删除单位信息，ID: {}", id);
        } catch (RRException e) {
            throw e;
        } catch (Exception e) {
            logger.error("删除单位信息失败，ID: {}", id, e);
            throw new RRException("删除单位信息失败：" + e.getMessage());
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteUomByCode(String uomCode) {
        try {
            if (StringUtils.isBlank(uomCode)) {
                throw new RRException("单位编码不能为空");
            }
            
            // 根据编码查找单位
            MstrUom existingUom = getUomByCode(uomCode);
            if (existingUom == null) {
                throw new RRException("单位不存在，编码: " + uomCode);
            }
            
            // 调用ID删除方法
            deleteUom(existingUom.getId());
        } catch (RRException e) {
            throw e;
        } catch (Exception e) {
            logger.error("根据编码删除单位信息失败，编码: {}", uomCode, e);
            throw new RRException("删除单位信息失败：" + e.getMessage());
        }
    }

    @Override
    public List<MstrUom> getUomsByStatus(String status) {
        try {
            if (StringUtils.isBlank(status)) {
                throw new RRException("状态不能为空");
            }
            
            Wrapper<MstrUom> wrapper = new EntityWrapper<>();
            wrapper.eq("is_deleted", 0);
            
            // 根据状态字段查询，这里假设状态字段为 allowDec
            if ("active".equalsIgnoreCase(status)) {
                wrapper.eq("allow_dec", 1);
            } else if ("inactive".equalsIgnoreCase(status)) {
                wrapper.eq("allow_dec", 0);
            }
            
            return mstrUomMapper.selectList(wrapper);
        } catch (RRException e) {
            throw e;
        } catch (Exception e) {
            logger.error("根据状态获取单位信息失败，状态: {}", status, e);
            throw new RRException("获取单位信息失败：" + e.getMessage());
        }
    }
    
    /**
     * 根据条件分页查询单位信息
     * @param page 页码
     * @param size 每页大小
     * @param name 名称模糊查询
     * @param allowDec 是否允许小数
     * @return 分页结果
     */
    public List<MstrUom> getUomsByPage(int page, int size, String name, Integer allowDec) {
        try {
            if (page <= 0) page = 1;
            if (size <= 0 || size > 1000) size = 20; // 限制最大查询数量，防止性能问题
            
            Wrapper<MstrUom> wrapper = new EntityWrapper<>();
            wrapper.eq("is_deleted", 0);
            
            if (StringUtils.isNotBlank(name)) {
                wrapper.like("desc_en", name.trim())
                       .or()
                       .like("desc_cn", name.trim())
                       .or()
                       .like("desc_hk", name.trim());
            }
            
            if (allowDec != null) {
                wrapper.eq("allow_dec", allowDec);
            }
            
            // 设置分页
            wrapper.last("LIMIT " + ((page - 1) * size) + ", " + size);
            
            return mstrUomMapper.selectList(wrapper);
        } catch (Exception e) {
            logger.error("分页查询单位信息失败，页码: {}, 大小: {}", page, size, e);
            throw new RRException("查询单位信息失败：" + e.getMessage());
        }
    }
    
    /**
     * 统计单位总数
     * @return 总数
     */
    public long countUoms() {
        try {
            Wrapper<MstrUom> wrapper = new EntityWrapper<>();
            wrapper.eq("is_deleted", 0);
            return mstrUomMapper.selectCount(wrapper);
        } catch (Exception e) {
            logger.error("统计单位总数失败", e);
            throw new RRException("统计单位总数失败：" + e.getMessage());
        }
    }
    
    /**
     * 批量删除单位（软删除）
     * @param ids 单位ID列表
     */
    @Transactional(rollbackFor = Exception.class)
    public void batchDeleteUoms(List<Long> ids) {
        try {
            if (ids == null || ids.isEmpty()) {
                throw new RRException("单位ID列表不能为空");
            }
            
            if (ids.size() > 100) {
                throw new RRException("批量删除数量不能超过100个");
            }
            
            int successCount = 0;
            for (Long id : ids) {
                try {
                    deleteUom(id);
                    successCount++;
                } catch (Exception e) {
                    logger.warn("删除单位失败，ID: {}, 错误: {}", id, e.getMessage());
                }
            }
            
            logger.info("批量删除单位完成，总数: {}, 成功: {}", ids.size(), successCount);
        } catch (RRException e) {
            throw e;
        } catch (Exception e) {
            logger.error("批量删除单位失败", e);
            throw new RRException("批量删除单位失败：" + e.getMessage());
        }
    }
    
    /**
     * 检查单位编码是否已存在
     * @param uomCode 单位编码
     * @param excludeId 排除的ID（用于更新时检查）
     * @return 是否存在
     */
    public boolean isUomCodeExists(String uomCode, Long excludeId) {
        try {
            if (StringUtils.isBlank(uomCode)) {
                return false;
            }
            
            Wrapper<MstrUom> wrapper = new EntityWrapper<>();
            wrapper.eq("desc_en", uomCode.trim())
                   .eq("is_deleted", 0);
            
            if (excludeId != null) {
                wrapper.ne("id", excludeId);
            }
            
            return mstrUomMapper.selectCount(wrapper) > 0;
        } catch (Exception e) {
            logger.error("检查单位编码是否存在失败，编码: {}", uomCode, e);
            return false;
        }
    }
    
    // 其他业务方法同理重构
} 